## Copyright (C) 2016 Jeremiah Orians
## This file is part of stage0.
##
## stage0 is free software: you an redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## stage0 is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with stage0.  If not, see <http://www.gnu.org/licenses/>.

:start
2D2D @table	# LOADUI R13 @table ; Where we are putting our table
# ;; We will be using R14 for our condition codes
2D2F7fff	# LOADUI R15 0x7FFF ; We will be using R15 for our stack


# ;; Main program functionality
# ;; Reads in Tape_01 and writes out results onto Tape_02
# ;; Accepts no arguments and HALTS when done
:main
# ;; Prep TAPE_01
2D201100	# LOADUI R0 0x1100
42100000	# FOPEN_READ
# ;; Intialize environment
0D00002C	# FALSE R12 ; Set holder to zero
0D00002B	# FALSE R11 ; Set PC counter to zero
2D2A0001	# LOADUI R10 1 ; Our toggle
# ;; Perform first pass
2D0F @first_pass	# CALLI R15 @first_pass
# ;; We need to rewind tape_01 to perform our second pass
2D201100	# LOADUI R0 0x1100
42100003	# REWIND
# ;; Reintialize environment
0D00002C	# FALSE R12 ; Set holder to zero
0D00002B	# FALSE R11 ; Set PC counter to zero
2D2A0001	# LOADUI R10 1 ; Our toggle
2D2900ff	# LOADUI R9 0xFF ; Byte mask
2D28000f	# LOADUI R8 0x0F ; nybble mask
# ;; Prep TAPE_02
2D201101	# LOADUI R0 0x1101
42100001	# FOPEN_WRITE
2D0F @second_pass	# CALLI R15 @second_pass
# ;; Close up as we are done
2D201100	# LOADUI R0 0x1100 ; Close TAPE_01
42100002	# FCLOSE
2D201101	# LOADUI R0 0x1101 ; Close TAPE_02
42100002	# FCLOSE
FFFFFFFF	# HALT


# ;; First pass function
# ;; Reads Tape_01 and creates our label table
# ;; Will Overwrite R0 R10 R11
# ;; Returns to Main function when done
:first_pass
2D211100	# LOADUI R1 0x1100 ; Read from tape_01
42100100	# FGETC ; Read a Char
# ;; Check for EOF
A0100000	# CMPSKIPI.GE R0 0
0D01001F	# RET R15
# ;; Check for and deal with label (:)
A030003a	# CMPSKIPI.NE R0 58
3C00 @storeLabel	# JUMP @storeLabel
# ;; Check for and deal with pointers to labels
# ;; Starting with (@)
A0300040	# CMPSKIPI.NE R0 64
3C00 @ThrowAwayPointer	# JUMP @ThrowAwayPointer
# ;; Then dealing with ($)
A0300024	# CMPSKIPI.NE R0 36
3C00 @ThrowAwayPointer	# JUMP @ThrowAwayPointer
# ;; Now check for absolute addresses (&)
A0300026	# CMPSKIPI.NE R0 38
3C00 @ThrowAwayAddress	# JUMP @ThrowAwayAddress
# ;; Otherwise attempt to process
2D0F @hex	# CALLI R15 @hex ; Convert it
A0100000	# CMPSKIPI.GE R0 0 ; Don't record, nonhex values
3C00 @first_pass	# JUMP @first_pass ; Move onto Next char
# ;; Determine if we got a full byte
2C9A @first_pass_0	# JUMP.Z R10 @first_pass_0 ; Jump if toggled
# ;; Deal with case of first half of byte
0D00002A	# FALSE R10 ; Flip the toggle
3C00 @first_pass	# JUMP @first_pass
:first_pass_0
# ;; Deal with case of second half of byte
0D00003A	# TRUE R10 ; Flip the toggle
0FBB0001	# ADDUI R11 R11 1 ; increment PC now that that we have a full byte
3C00 @first_pass	# JUMP @first_pass


# ;; Second pass function
# ;; Reads from Tape_01 and uses the values in the table
# ;; To write desired contents onto Tape_02
# ;; Will Overwrite R0 R10 R11
# ;; Returns to Main function when done
:second_pass
2D211100	# LOADUI R1 0x1100 ; Read from tape_01
42100100	# FGETC ; Read a Char
# ;; Check for EOF
A0100000	# CMPSKIPI.GE R0 0
0D01001F	# RET R15
# ;; Check for and deal with label
A030003a	# CMPSKIPI.NE R0 58
3C00 @ThrowAwayLabel	# JUMP @ThrowAwayLabel
# ;; Check for and deal with Pointers to labels
A0300040	# CMPSKIPI.NE R0 64 ; @ for relative
3C00 @StoreRelativePointer	# JUMP @StoreRelativePointer
A0300024	# CMPSKIPI.NE R0 36 ; $ for absolute
3C00 @StoreAbsolutePointer	# JUMP @StoreAbsolutePointer
A0300026	# CMPSKIPI.NE R0 38 ; & for address
3C00 @StoreAbsoluteAddress	# JUMP @StoreAbsoluteAddress
# ;; Process everything else
2D0F @hex	# CALLI R15 @hex ; Attempt to Convert it
A0100000	# CMPSKIPI.GE R0 0 ; Don't record, nonhex values
3C00 @second_pass	# JUMP @second_pass ; Move onto Next char
# ;; Determine if we got a full byte
2C9A @second_pass_0	# JUMP.Z R10 @second_pass_0 ; Jump if toggled
# ;; Deal with case of first half of byte
05020C08	# AND R12 R0 R8 ; Store our first nibble
0D00002A	# FALSE R10 ; Flip the toggle
3C00 @second_pass	# JUMP @second_pass
:second_pass_0
# ;; Deal with case of second half of byte
2D5C0004	# SL0I R12 4 ; Shift our first nybble
05020008	# AND R0 R0 R8 ; Mask out top
0500000C	# ADD R0 R0 R12 ; Combine nybbles
0D00003A	# TRUE R10 ; Flip the toggle
2D211101	# LOADUI R1 0x1101 ; Write the combined byte
42100200	# FPUTC ; To TAPE_02
0FBB0001	# ADDUI R11 R11 1 ; increment PC now that that we have a full byte
3C00 @second_pass	# JUMP @second_pass


# ;; Store Label function
# ;; Writes out the token and the current PC value
# ;; Its static variable for storing the next index to be used
# ;; Will overwrite R0
# ;; Returns to first pass when done
:storeLabel
2E00 @current_index	# LOADR R0 @current_index ; Get address of first open index
A0300000	# CMPSKIPI.NE R0 0 ; If zero intialize from R13
0900040D	# COPY R0 R13
# ;; Store the PC of the label
23B00000	# STORE32 R11 R0 0
# ;; Store the name of the Label
0F000004	# ADDUI R0 R0 4 ; Increment the offset of the index
2D0F @writeout_token	# CALLI R15 @writeout_token
# ;; Update our index
0F00003c	# ADDUI R0 R0 60 ; Hopefully our tokens are less than 60 bytes long
2F00 @current_index	# STORER R0 @current_index
# ;; And be done
3C00 @first_pass	# JUMP @first_pass
# ;; Where we are storing the location of the next free table entry
:current_index
00000000	# NOP


# ;; StoreRelativepointer function
# ;; Deals with the special case of relative pointers
# ;; Clears Temp
# ;; Stores string in Temp
# ;; Finds match in Table
# ;; Writes out the offset
# ;; Modifies R0 R11
# ;; Jumps back into Pass2
:StoreRelativePointer
# ;; Correct the PC to reflect the size of the pointer
0FBB0002	# ADDUI R11 R11 2 ; Exactly 2 bytes
2D20 $Temp	# LOADUI R0 $Temp ; Set where we want to shove our string
2D0F @Clear_string	# CALLI R15 @Clear_string ; Clear it
2D0F @writeout_token	# CALLI R15 @writeout_token ; Write it
2D0F @Match_string	# CALLI R15 @Match_string ; Find the Match
1800fffc	# LOAD32 R0 R0 -4 ; Get the value we care about
0500200B	# SUB R0 R0 R11 ; Determine the difference
0F000004	# ADDUI R0 R0 4 ; Adjust for relative positioning
2D0F @ProcessImmediate	# CALLI R15 @ProcessImmediate ; Write out the value
3C00 @second_pass	# JUMP @second_pass


# ;; StoreAbsolutepointer function
# ;; Deals with the special case of absolute pointers
# ;; Clears Temp
# ;; Stores string in Temp
# ;; Finds match in Table
# ;; Writes out the absolute address of match
# ;; Modifies R0 R11
# ;; Jumps back into Pass2
:StoreAbsolutePointer
# ;; Correct the PC to reflect the size of the pointer
0FBB0002	# ADDUI R11 R11 2 ; Exactly 2 bytes
2D20 $Temp	# LOADUI R0 $Temp ; Set where we want to shove our string
2D0F @Clear_string	# CALLI R15 @Clear_string ; Clear it
2D0F @writeout_token	# CALLI R15 @writeout_token ; Write it
2D0F @Match_string	# CALLI R15 @Match_string ; Find the Match
1800fffc	# LOAD32 R0 R0 -4 ; Get the value we care about
2D0F @ProcessImmediate	# CALLI R15 @ProcessImmediate ; Write out the value
3C00 @second_pass	# JUMP @second_pass


# ;; StoreAbsoluteAddress function
# ;; Deal with the special case of absolute Addresses
# ;; Clear Temp
# ;; Stores string in Temp
# ;; Finds match in Table
# ;; Writes out the full absolute address [32 bit machine]
# ;; Modifies R0 R11
# ;; Jumpbacs back into Pass2
:StoreAbsoluteAddress
# ;; COrrect the PC to reflect the size of the address
0FBB0004	# ADDUI R11 R11 4 ; 4 Bytes on 32bit machines
2D20 $Temp	# LOADUI R0 $Temp ; Set where we ant to shove our string
2D0F @Clear_string	# CALLI R15 @Clear_string ; Clear it
2D0F @writeout_token	# CALLI R15 @writeout_token ; Write it
2D0F @Match_string	# CALLI R15 @Match_string ; Find the Match
090200EF	# PUSHR R14 R15 ; Get a temp storage place
18E0fffc	# LOAD32 R14 R0 -4 ; Get the value we care about
0900040E	# COPY R0 R14 ; We need to print the top 2 bytes first
2D400010	# SARI R0 16 ; Drop bottom 16 bits
2D0F @ProcessImmediate	# CALLI R15 @ProcessImmediate ; Write out top 2 bytes
2D20ffff	# LOADUI R0 0xFFFF ; Provide mask to keep bottom 2 bytes
0502000E	# AND R0 R0 R14 ; Drop top 16 bits
090280EF	# POPR R14 R15 ; Restore R14
2D0F @ProcessImmediate	# CALLI R15 @ProcessImmediate ; Write out bottom 2 bytes
3C00 @second_pass	# JUMP @second_pass


# ;; Writeout Token Function
# ;; Writes the Token [minus first char] to the address
# ;; It recieves in R0 until it reaches a delimiter
# ;; All register values are preserved
# ;; Returns to whatever called it
:writeout_token
# ;; Preserve registers
0902000F	# PUSHR R0 R15
0902001F	# PUSHR R1 R15
0902002F	# PUSHR R2 R15
# ;; Initialize
09000520	# MOVE R2 R0 ; Set R2 as our index
2D211100	# LOADUI R1 0x1100 ; Read from tape_01
# ;; Our core loop
:writeout_token_0
42100100	# FGETC ; Get another byte
# ;; Deal with termination cases
A0300020	# CMPSKIPI.NE R0 32 ; Finished if space
3C00 @writeout_token_done	# JUMP @writeout_token_done
A0300009	# CMPSKIPI.NE R0 9 ; Finished if tab
3C00 @writeout_token_done	# JUMP @writeout_token_done
A030000a	# CMPSKIPI.NE R0 10 ; Finished if newline
3C00 @writeout_token_done	# JUMP @writeout_token_done
# ;; Deal with valid input
21020000	# STORE8 R0 R2 0 ; Write out the byte
0F220001	# ADDUI R2 R2 1 ; Increment
3C00 @writeout_token_0	# JUMP @writeout_token_0 ; Keep looping
# ;; Clean up now that we are done
:writeout_token_done
# ;; Restore registers
0902802F	# POPR R2 R15
0902801F	# POPR R1 R15
0902800F	# POPR R0 R15
# ;; And be done
0D01001F	# RET R15


# ;; Clear string function
# ;; Clears string pointed at by the value of R0
# ;; Until a null character is reached
# ;; Doesn't alter any registers
# ;; Returns to the function that calls it
:Clear_string
# ;; Preserve registers
0902000F	# PUSHR R0 R15
0902001F	# PUSHR R1 R15
0902002F	# PUSHR R2 R15
0902003F	# PUSHR R3 R15
# ;; Setup registers
09000510	# MOVE R1 R0
2D220000	# LOADUI R2 0
2D230000	# LOADUI R3 0
:clear_byte
0503A012	# LOADXU8 R0 R1 R2 ; Get the byte
05049312	# STOREX8 R3 R1 R2 ; Overwrite with a Zero
0F220001	# ADDUI R2 R2 1 ; Prep for next loop
2CA0 @clear_byte	# JUMP.NZ R0 @clear_byte ; Stop if byte is NULL
# ;; Done
# ;; Restore registers
0902803F	# POPR R3 R15
0902802F	# POPR R2 R15
0902801F	# POPR R1 R15
0902800F	# POPR R0 R15
0D01001F	# RET R15


# ;; Match string function
# ;; Walks down table until match is found
# ;; Then returns address of matching string in R0
# ;; Returns to whatever called it
:Match_string
# ;; Preserve registers
0902001F	# PUSHR R1 R15
0902002F	# PUSHR R2 R15
# ;; Initialize for Loop
2D21 $Temp	# LOADUI R1 $Temp ; We always compare against Temp
2D22 $table	# LOADUI R2 $table ; Begin at start of table
0F220004	# ADDUI R2 R2 4 ; Where the string is located
# ;; Loop until we find a match
:Match_string_0
09000402	# COPY R0 R2 ; Set R0 to our current string
2D0F @strcmp	# CALLI R15 @strcmp
2C50 @Match_string_1	# JUMP.E R0 @Match_string_1 ; It is a match!
# ;; Prepare for next loop
2D21 $Temp	# LOADUI R1 $Temp ; That function clears R1
0F220040	# ADDUI R2 R2 64 ; Each Index is 64 bytes
3C00 @Match_string_0	# JUMP @Match_string_0 ; Keep looping
:Match_string_1
# ;; Store the correct answer
09000502	# MOVE R0 R2
# ;; Restore registers
0902802F	# POPR R2 R15
0902801F	# POPR R1 R15
0D01001F	# RET R15


# ;; Our simple string compare function
# ;; Recieves two pointers in R0 and R1
# ;; Returns the difference between the strings in R0
# ;; Clears R1
# ;; Returns to whatever called it
:strcmp
# ;; Preserve registers
0902002F	# PUSHR R2 R15
0902003F	# PUSHR R3 R15
0902004F	# PUSHR R4 R15
# ;; Setup registers
09000520	# MOVE R2 R0
09000531	# MOVE R3 R1
2D240000	# LOADUI R4 0
:cmpbyte
0503A024	# LOADXU8 R0 R2 R4 ; Get a byte of our first string
0503A134	# LOADXU8 R1 R3 R4 ; Get a byte of our second string
0F440001	# ADDUI R4 R4 1 ; Prep for next loop
05004101	# CMP R1 R0 R1 ; Compare the bytes
A0200000	# CMPSKIPI.E R0 0 ; Stop if byte is NULL
2C51 @cmpbyte	# JUMP.E R1 @cmpbyte ; Loop if bytes are equal
# ;; Done
09000501	# MOVE R0 R1 ; Prepare for return
# ;; Restore registers
0902804F	# POPR R4 R15
0902803F	# POPR R3 R15
0902802F	# POPR R2 R15
0D01001F	# RET R15


# ;; Processimmediate Function
# ;; Recieves an integer value in R0
# ;; Writes out the values to Tape_02
# ;; Doesn't modify registers
# ;; Returns to whatever called it
:ProcessImmediate
# ;; Preserve registers
0902000F	# PUSHR R0 R15
0902001F	# PUSHR R1 R15
0902002F	# PUSHR R2 R15
# ;; Break up Immediate
05020209	# AND R2 R0 R9 ; Put lower byte in R2
2D400008	# SARI R0 8 ; Drop Bottom byte from R0
05020009	# AND R0 R0 R9 ; Maskout everything outside of top byte
# ;; Write out Top Byte
2D211101	# LOADUI R1 0x1101 ; Write the byte
42100200	# FPUTC ; To TAPE_02
# ;; Write out bottom Byte
09000502	# MOVE R0 R2 ; Put Lower byte in R0
2D211101	# LOADUI R1 0x1101 ; Write the byte
42100200	# FPUTC ; To TAPE_02
# ;; Restore registers
0902802F	# POPR R2 R15
0902801F	# POPR R1 R15
0902800F	# POPR R0 R15
# ;; Be Done
0D01001F	# RET R15


# ;; ThrowAwaypointer function
# ;; Handle the special case of a generic problem
# ;; for Pass1, Will update R11 and modify R0
# ;; Will return to the start of first_pass
# ;; Never call this function, only jump to it
:ThrowAwayPointer
0FBB0002	# ADDUI R11 R11 2 ; Pointers always take up 2 bytes
2D0F @throwAwayToken	# CALLI R15 @throwAwayToken ; Get rid of rest of token
3C00 @first_pass	# JUMP @first_pass ; Then return to the proper place


# ;; ThrowAwayAddress function
# ;; Handle the case of a 32bit absolute address storage
# ;; for Pass1, Will update R11 and modify R0
# ;; Will return to the start of first_pass
# ;; Never call this function, conly jump to it
:ThrowAwayAddress
0FBB0004	# ADDUI R11 R11 4 ; Addresses on 32bit systems take up 4 bytes
2D0F @throwAwayToken	# CALLI R15 @throwAwayToken ; Get rid of rest of token
3C00 @first_pass	# JUMP @first_pass ; Then return to the proper place


# ;; ThrowAwaylabel function
# ;; Handle the special case of a generic problem
# ;; for Pass2, Will update R11 and modify R0
# ;; Will return to the start of second_pass
# ;; Never call this function, only jump to it
:ThrowAwayLabel
2D0F @throwAwayToken	# CALLI R15 @throwAwayToken ; Get rid of rest of token
3C00 @second_pass	# JUMP @second_pass

# ;; Throw away token function
# ;; Deals with the general case of not wanting
# ;; The rest of the characters in a token
# ;; This Will alter the values of R0 R1
# ;; Returns back to whatever called it
:throwAwayToken
2D211100	# LOADUI R1 0x1100 ; Read from tape_01
42100100	# FGETC ; Read a Char
# ;; Stop looping if space
A0300020	# CMPSKIPI.NE R0 32
0D01001F	# RET R15
# ;; Stop looping if tab
A0300009	# CMPSKIPI.NE R0 9
0D01001F	# RET R15
# ;; Stop looping if newline
A030000a	# CMPSKIPI.NE R0 10
0D01001F	# RET R15
# ;; Otherwise keep looping
3C00 @throwAwayToken	# JUMP @throwAwayToken

# ;; Hex function
# ;; This function is serving three purposes:
# ;; Identifying hex characters
# ;; Purging line comments
# ;; Returning the converted value of a hex character
# ;; This function will alter the values of R0 R14
# ;; Returns back to whatever called it
:hex
# ;; Deal with line comments starting with #
1FE00023	# CMPUI R14 R0 35
2C5E @ascii_comment	# JUMP.E R14 @ascii_comment
# ;; Deal with line comments starting with ;
1FE0003b	# CMPUI R14 R0 59
2C5E @ascii_comment	# JUMP.E R14 @ascii_comment
# ;; Deal with all ascii less than '0'
1FE00030	# CMPUI R14 R0 48
2C8E @ascii_other	# JUMP.L R14 @ascii_other
# ;; Deal with '0'-'9'
1FE00039	# CMPUI R14 R0 57
2C7E @ascii_num	# JUMP.LE R14 @ascii_num
# ;; Deal with all ascii less than 'A'
1FE00041	# CMPUI R14 R0 65
2C8E @ascii_other	# JUMP.L R14 @ascii_other
# ;; Deal with 'A'-'F'
1FE00046	# CMPUI R14 R0 70
2C7E @ascii_high	# JUMP.LE R14 @ascii_high
# ;; Deal with all ascii less than 'a'
1FE00061	# CMPUI R14 R0 97
2C8E @ascii_other	# JUMP.L R14 @ascii_other
# ;;  Deal with 'a'-'f'
1FE00066	# CMPUI R14 R0 102
2C7E @ascii_low	# JUMP.LE R14 @ascii_low
# ;; Ignore the rest
3C00 @ascii_other	# JUMP @ascii_other
:ascii_num
11000030	# SUBUI R0 R0 48
0D01001F	# RET R15
:ascii_low
11000057	# SUBUI R0 R0 87
0D01001F	# RET R15
:ascii_high
11000037	# SUBUI R0 R0 55
0D01001F	# RET R15
:ascii_other
0D000030	# TRUE R0
0D01001F	# RET R15
:ascii_comment
2D211100	# LOADUI R1 0x1100 ; Read from TAPE_01
42100100	# FGETC ; Read another char
1FE0000a	# CMPUI R14 R0 10 ; Stop at the end of line
2C6E @ascii_comment	# JUMP.NE R14 @ascii_comment ; Otherwise keep looping
3C00 @ascii_other	# JUMP @ascii_other


# ;; Where we are storing our Temp
:Temp
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP
00000000	# NOP


# ;; Where we will putting our Table
:table
